/**
 *
 * @param <T>:代表当前类是一个 泛型类
 */

class MyArray<T> {
//    public T[] array2=new T[10];//泛型不能被实例化，它只是在编译期间起到检查作用，不是替换

    public Object[] array=new Object[10];

    public void setValue(int pos,T x) {
        array[pos]=x;
    }

    public T getValue(int pos) {
        return (T)array[pos];
    }

    public Object[] getArray() {
        return array;
    }
}



//泛型的上界
class Alg<T extends Comparable<T>>  {   //泛型会被类型擦除成Object，但是Object没有实现任何接口
    //这个方法的类型是泛型，对于无论什么类型，都能找到最大值
    public T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(array[i].compareTo(max)>0) { //引用类型进行比较，不能直接用大于小于号，要实现comparable接口
                max=array[i];
            }
        }
        return max;
    }
}

class Alg2{
    public <T extends Comparable<T>> T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(array[i].compareTo(max)>0) {
                max=array[i];
            }
        }
        return max;
    }
}

class Alg3 {
    public static <T extends Comparable<T>> T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(array[i].compareTo(max)>0) {
                max=array[i];
            }
        }
        return max;
    }
}


public class Test {

    public static void main(String[] args) {
        Integer[] array={1,2,3,4,5};
        Integer x=Alg3.<Integer>findMax(array);//通过类名直接调用静态泛型方法
        System.out.println(x);
    }


    public static void main6(String[] args) {
        Alg2 alg2=new Alg2();
        Integer[] array={1,2,3,4,5};
        Integer x=alg2.<Integer>findMax(array);
        System.out.println(x);

    }

    public static void main5(String[] args) {
        Alg<Integer> alg=new Alg<Integer>();
        Integer[] array={1,2,3,4,5};
        Integer x=alg.findMax(array);
        System.out.println(x);
    }

    public static void main4(String[] args) {
        MyArray<String> myArray4=new MyArray<>();
//        String[] strings=myArray4.getArray();//Object类型的数组不能转换为String类型的数组
    }

    public static void main3(String[] args) {
        MyArray<Integer> myArray=new MyArray<>();
        myArray.setValue(0,1);
        myArray.setValue(1,2);
//        myArray.setValue(2,"hello");

        Integer x=myArray.getValue(0);//此时不需要进行强制类型转换
        System.out.println(x);

        System.out.println("======================");
        MyArray<String> myArray2=new MyArray<>();
        myArray2.setValue(0,"hello");

//        MyArray<int> myArray3=new MyArray<int>();
    }
    public static void main2(String[] args) {
        MyArray myArray=new MyArray();
        myArray.setValue(0,10);
        myArray.setValue(1,8.0);
        myArray.setValue(2,"hello");//数组啥类型都能放，看似很方便，但实则很不方便取值

        String s=(String)myArray.getValue(2);//面对大量数据，对每个要取出的值都进行强转时不现实的
        System.out.println(s);

    }

    public static void main1(String[] args) {
        //装箱
        Integer a=100;
        Integer b=100;
        System.out.println(a==b);//true

        Integer c=200;
        Integer d=200;
        System.out.println(c==d);//false
    }
}
